home *** CD-ROM | disk | FTP | other *** search
/ Sprite 1984 - 1993 / Sprite 1984 - 1993.iso / src / cmds / ld / dist / patch / ld.c.rej < prev    next >
Encoding:
Text File  |  1990-10-26  |  62.4 KB  |  2,338 lines
  1. ***************
  2. *** 23,37 ****
  3.   #include <sys/types.h>
  4.   #include <sys/stat.h>
  5.   #include <sys/file.h>
  6.   #ifndef sony_news
  7.   #include <fcntl.h>
  8.   #endif
  9.   
  10.   #ifdef COFF_ENCAPSULATE
  11.   #include "a.out.encap.h"
  12.   #else
  13.   #include <a.out.h>
  14.   #endif
  15.   
  16.   #ifndef N_SET_MAGIC
  17.   #define N_SET_MAGIC(exec, val)  ((exec).a_magic = val)
  18. --- 23,60 ----
  19.   #include <sys/types.h>
  20.   #include <sys/stat.h>
  21.   #include <sys/file.h>
  22. + #ifndef USG
  23. + #include <sys/time.h>
  24. + #include <sys/resource.h>
  25. + #endif
  26.   #ifndef sony_news
  27.   #include <fcntl.h>
  28.   #endif
  29.   
  30. + #if !defined(A_OUT) && !defined(MACH_O)
  31. + #define A_OUT
  32. + #endif
  33. + 
  34. + #ifdef A_OUT
  35.   #ifdef COFF_ENCAPSULATE
  36.   #include "a.out.encap.h"
  37.   #else
  38.   #include <a.out.h>
  39.   #endif
  40. + #endif
  41. + 
  42. + #ifdef MACH_O
  43. + #ifndef A_OUT
  44. + #include <nlist.h>
  45. + #include <reloc.h>
  46. + #endif
  47. + #ifndef N_TEXT
  48. + #define N_TEXT 0x04
  49. + #define N_DATA 0x06
  50. + #define N_BSS 0x08
  51. + #endif
  52. + #include <sys/loader.h>
  53. + #endif
  54.   
  55.   #ifndef N_SET_MAGIC
  56.   #define N_SET_MAGIC(exec, val)  ((exec).a_magic = val)
  57. ***************
  58. *** 219,235 ****
  59.   /* Define this to specify the default executable format.  */
  60.   
  61.   #ifdef hpux
  62. ! #define DEFAULT_MAGIC NMAGIC  /* hpux bugs screw ZMAGIC */
  63.   #endif
  64.   
  65. - #ifndef DEFAULT_MAGIC
  66. - #define DEFAULT_MAGIC ZMAGIC
  67. - #endif
  68. - 
  69.   /* Ordinary 4.3bsd lacks these macros in a.out.h.  */
  70.   
  71.   #ifndef N_TXTADDR
  72. ! #if defined(vax) || defined(sony_news)
  73.   #define N_TXTADDR(X) 0
  74.   #endif
  75.   #ifdef is68k
  76. --- 250,262 ----
  77.   /* Define this to specify the default executable format.  */
  78.   
  79.   #ifdef hpux
  80. ! #define DEFAULT_OUTPUT_STYLE OUTPUT_READONLY_TEXT
  81.   #endif
  82.   
  83.   /* Ordinary 4.3bsd lacks these macros in a.out.h.  */
  84.   
  85.   #ifndef N_TXTADDR
  86. ! #if defined(vax) || defined(sony_news) || defined(hp300) || defined(pyr)
  87.   #define N_TXTADDR(X) 0
  88.   #endif
  89.   #ifdef is68k
  90. ***************
  91. *** 238,247 ****
  92.   #ifdef sequent
  93.   #define    N_TXTADDR(x) (N_ADDRADJ(x))
  94.   #endif
  95.   #endif
  96.   
  97.   #ifndef N_DATADDR
  98. ! #if defined(vax) || defined(sony_news)
  99.   #define N_DATADDR(x) \
  100.       (((x).a_magic==OMAGIC)? (N_TXTADDR(x)+(x).a_text) \
  101.       : (page_size+((N_TXTADDR(x)+(x).a_text-1) & ~(page_size-1))))
  102. --- 265,277 ----
  103.   #ifdef sequent
  104.   #define    N_TXTADDR(x) (N_ADDRADJ(x))
  105.   #endif
  106. + #ifdef NeXT
  107. + #define N_TXTADDR(X) ((X).a_magic == ZMAGIC ? page_size : 0)
  108. + #endif
  109.   #endif
  110.   
  111.   #ifndef N_DATADDR
  112. ! #if defined(vax) || defined(sony_news) || defined(hp300) || defined(pyr)
  113.   #define N_DATADDR(x) \
  114.       (((x).a_magic==OMAGIC)? (N_TXTADDR(x)+(x).a_text) \
  115.       : (page_size+((N_TXTADDR(x)+(x).a_text-1) & ~(page_size-1))))
  116. ***************
  117. *** 264,277 ****
  118.   #ifdef sparc
  119.   #define INITIALIZE_HEADER \
  120.     {outheader.a_machtype = M_SPARC; outheader.a_toolversion = 1;}
  121. ! #endif
  122. ! #if defined(mc68010) || defined(m68010)
  123. ! #define INITIALIZE_HEADER outheader.a_machtype = M_68010
  124. ! #endif
  125. ! #ifndef INITIALIZE_HEADER
  126. ! #define INITIALIZE_HEADER outheader.a_machtype = M_68020
  127. ! #endif
  128. ! #endif
  129.   #ifdef ALTOS
  130.   #define INITIALIZE_HEADER N_SET_MACHTYPE (outheader, M_68020)
  131.   #endif
  132. --- 306,328 ----
  133.   #ifdef sparc
  134.   #define INITIALIZE_HEADER \
  135.     {outheader.a_machtype = M_SPARC; outheader.a_toolversion = 1;}
  136. ! #endif /* sparc.  */
  137. ! #if defined(mc68000)
  138. ! /* Set the machine type according to the machine type of the .o files.
  139. !    If they are all sun2 (68010), then the type of the executable is sun2.
  140. !    If any is sun3 (68020), then the type of the executable is sun3.
  141. !    This is consistent with the Sun loader and more useful than having
  142. !    it depend on which machine you are on when you run ld.  */
  143. ! static int sun_machtype = M_68010;
  144. ! #define INITIALIZE_HEADER outheader.a_machtype = sun_machtype
  145. ! #define READ_HEADER_HOOK(machtype) \
  146. !   if (machtype == M_68020)           \
  147. !     {                     \
  148. !       sun_machtype = M_68020;         \
  149. !     }
  150. ! #endif /* mc68000.  */
  151. ! #endif /* Sun.  */
  152. ! 
  153.   #ifdef ALTOS
  154.   #define INITIALIZE_HEADER N_SET_MACHTYPE (outheader, M_68020)
  155.   #endif
  156. ***************
  157. *** 288,294 ****
  158.   #endif
  159.   #if defined(i386) && !defined(sequent)
  160.   #define INITIALIZE_HEADER N_SET_MACHTYPE (outheader, M_386)
  161. ! #endif
  162.   
  163.   #ifdef is68k
  164.   /* This enables code to take care of an ugly hack in the ISI OS.
  165. --- 339,351 ----
  166.   #endif
  167.   #if defined(i386) && !defined(sequent)
  168.   #define INITIALIZE_HEADER N_SET_MACHTYPE (outheader, M_386)
  169. ! #endif /* Sequent symmetry.  */
  170. ! #if defined(hp300)
  171. ! #define INITIALIZE_HEADER outheader.a_mid = MID_HP300
  172. ! #endif /* hp300.  */
  173. ! #ifdef pyr
  174. ! #define INITIALIZE_HEADER outheader.a_machid = PYR90X
  175. ! #endif /* Pyramid.  */
  176.   
  177.   #ifdef is68k
  178.   /* This enables code to take care of an ugly hack in the ISI OS.
  179. ***************
  180. *** 390,402 ****
  181.   /* Sparc (Sun 4) macros */
  182.   #undef relocation_info
  183.   #define relocation_info                    reloc_info_sparc
  184. ! #define RELOC_ADDRESS(r)        ((r)->r_address)                 
  185. ! #define RELOC_EXTERN_P(r)               ((r)->r_extern)      
  186. ! #define RELOC_TYPE(r)                   ((r)->r_index)  
  187. ! #define RELOC_SYMBOL(r)                 ((r)->r_index)   
  188.   #define RELOC_MEMORY_SUB_P(r)        0
  189.   #define RELOC_MEMORY_ADD_P(r)           0
  190. ! #define RELOC_ADD_EXTRA(r)              ((r)->r_addend)       
  191.   #define RELOC_PCREL_P(r)             \
  192.           ((r)->r_type >= RELOC_DISP8 && (r)->r_type <= RELOC_WDISP22)
  193.   #define RELOC_VALUE_RIGHTSHIFT(r)       (reloc_target_rightshift[(r)->r_type])
  194. --- 445,457 ----
  195.   /* Sparc (Sun 4) macros */
  196.   #undef relocation_info
  197.   #define relocation_info                    reloc_info_sparc
  198. ! #define RELOC_ADDRESS(r)        ((r)->r_address)
  199. ! #define RELOC_EXTERN_P(r)               ((r)->r_extern)
  200. ! #define RELOC_TYPE(r)                   ((r)->r_index)
  201. ! #define RELOC_SYMBOL(r)                 ((r)->r_index)
  202.   #define RELOC_MEMORY_SUB_P(r)        0
  203.   #define RELOC_MEMORY_ADD_P(r)           0
  204. ! #define RELOC_ADD_EXTRA(r)              ((r)->r_addend)
  205.   #define RELOC_PCREL_P(r)             \
  206.           ((r)->r_type >= RELOC_DISP8 && (r)->r_type <= RELOC_WDISP22)
  207.   #define RELOC_VALUE_RIGHTSHIFT(r)       (reloc_target_rightshift[(r)->r_type])
  208. ***************
  209. *** 1124,1171 ****
  210.   
  211.     decode_command (argc, argv);
  212.   
  213. -   /* Create the symbols `etext', `edata' and `end'.  */
  214. - 
  215. -   if (!relocatable_output)
  216. -     symtab_init ();
  217. - 
  218. -   /* Determine whether to count the header as part of
  219. -      the text size, and initialize the text size accordingly.
  220. -      This depends on the kind of system and on the output format selected.  */
  221. - 
  222. -   N_SET_MAGIC (outheader, magic);
  223. - #ifdef INITIALIZE_HEADER
  224. -   INITIALIZE_HEADER;
  225. - #endif
  226. - 
  227. -   text_size = sizeof (struct exec);
  228. - #ifdef COFF_ENCAPSULATE
  229. -   if (relocatable_output == 0)
  230. -     {
  231. -       need_coff_header = 1;
  232. -       /* set this flag now, since it will change the values of N_TXTOFF, etc */
  233. -       N_SET_FLAGS (outheader, N_FLAGS_COFF_ENCAPSULATE);
  234. -       text_size += sizeof (struct coffheader);
  235. -     }
  236. - #endif
  237. - 
  238. -   text_size -= N_TXTOFF (outheader);
  239. - 
  240. -   if (text_size < 0)
  241. -     text_size = 0;
  242. -   entry_offset = text_size;
  243. - 
  244. -   if (!T_flag_specified && !relocatable_output)
  245. -     text_start = N_TXTADDR (outheader);
  246. - 
  247. -   /* The text-start address is normally this far past a page boundary.  */
  248. -   text_start_alignment = text_start % page_size;
  249. - 
  250.     /* Load symbols of all input files.
  251.        Also search all libraries and decide which library members to load.  */
  252.   
  253.     load_symbols ();
  254.   
  255.     /* Compute where each file's sections go, and relocate symbols.  */
  256.   
  257.     digest_symbols ();
  258. --- 1283,1300 ----
  259.   
  260.     decode_command (argc, argv);
  261.   
  262.     /* Load symbols of all input files.
  263.        Also search all libraries and decide which library members to load.  */
  264.   
  265.     load_symbols ();
  266.   
  267. +   /* Create various built-in symbols.  This must occur after
  268. +      all input files are loaded so that a user program can have a
  269. +      symbol named etext (for example).  */
  270. + 
  271. +   if (output_style != OUTPUT_RELOCATABLE)
  272. +     symtab_init ();
  273. + 
  274.     /* Compute where each file's sections go, and relocate symbols.  */
  275.   
  276.     digest_symbols ();
  277. ***************
  278. *** 1187,1238 ****
  279.     exit (!make_executable);
  280.   }
  281.   
  282. ! void decode_option ();
  283. ! 
  284. ! /* Analyze a command line argument.
  285. !    Return 0 if the argument is a filename.
  286. !    Return 1 if the argument is a option complete in itself.
  287. !    Return 2 if the argument is a option which uses an argument.
  288. ! 
  289. !    Thus, the value is the number of consecutive arguments
  290. !    that are part of options.  */
  291. ! 
  292. ! int
  293. ! classify_arg (arg)
  294. !      register char *arg;
  295. ! {
  296. !   if (*arg != '-') return 0;
  297. !   switch (arg[1])
  298. !     {
  299. !     case 'A':
  300. !     case 'D':
  301. !     case 'e':
  302. !     case 'L':
  303. !     case 'l':
  304. !     case 'o':
  305. !     case 'u':
  306. !     case 'V':
  307. !     case 'y':
  308. !       if (arg[2])
  309. !     return 1;
  310. !       return 2;
  311. ! 
  312. !     case 'B':
  313. !       if (! strcmp (&arg[2], "static"))
  314. !     return 1;
  315. ! 
  316. !     case 'T':
  317. !       if (arg[2] == 0)
  318. !     return 2;
  319. !       if (! strcmp (&arg[2], "text"))
  320. !     return 2;
  321. !       if (! strcmp (&arg[2], "data"))
  322. !     return 2;
  323. !       return 1;
  324. !     }
  325.   
  326. !   return 1;
  327. ! }
  328.   
  329.   /* Process the command arguments,
  330.      setting up file_table with an entry for each input file,
  331. --- 1316,1357 ----
  332.     exit (!make_executable);
  333.   }
  334.   
  335. ! void add_cmdline_ref ();
  336.   
  337. ! static struct option longopts[] =
  338. ! {
  339. !   {"d", 0, 0, 'd'},
  340. !   {"dc", 0, 0, 'd'},        /* For Sun compatibility. */
  341. !   {"dp", 0, 0, 'd'},        /* For Sun compatibility. */
  342. !   {"e", 1, 0, 'e'},
  343. !   {"n", 0, 0, 'n'},
  344. !   {"noinhibit-exec", 0, 0, 130},
  345. !   {"nostdlib", 0, 0, 133},
  346. !   {"o", 1, 0, 'o'},
  347. !   {"r", 0, 0, 'r'},
  348. !   {"s", 0, 0, 's'},
  349. !   {"t", 0, 0, 't'},
  350. !   {"u", 1, 0, 'u'},
  351. !   {"x", 0, 0, 'x'},
  352. !   {"z", 0, 0, 'z'},
  353. !   {"A", 1, 0, 'A'},
  354. !   {"Bstatic", 0, 0, 129},    /* For Sun compatibility. */
  355. !   {"D", 1, 0, 'D'},
  356. !   {"M", 0, 0, 'M'},
  357. !   {"N", 0, 0, 'N'},
  358. !   {"S", 0, 0, 'S'},
  359. !   {"T", 1, 0, 'T'},
  360. !   {"Ttext", 1, 0, 'T'},
  361. !   {"Tdata", 1, 0, 132},
  362. !   {"V", 1, 0, 'V'},
  363. !   {"X", 0, 0, 'X'},
  364. !   {0, 0, 0, 0}
  365. ! };
  366. ! 
  367. ! /* Since the Unix ld accepts -lfoo, -Lfoo, and -yfoo, we must also.
  368. !    This effectively prevents any long options from starting with
  369. !    one of these letters. */
  370. ! #define SHORTOPTS "-l:y:L:"
  371.   
  372.   /* Process the command arguments,
  373.      setting up file_table with an entry for each input file,
  374. ***************
  375. *** 1116,1211 ****
  376.     n_search_dirs = 0;
  377.     search_dirs = (char **) xmalloc (sizeof (char *));
  378.   
  379. !   /* First compute number_of_files so we know how long to make file_table.  */
  380. !   /* Also process most options completely.  */
  381.   
  382. !   for (i = 1; i < argc; i++)
  383. !     {
  384. !       register int code = classify_arg (argv[i]);
  385. !       if (code)
  386. !     {
  387. !       if (i + code > argc)
  388. !         fatal ("no argument following %s\n", argv[i]);
  389. ! 
  390. !       decode_option (argv[i], argv[i+1]);
  391. ! 
  392. !       if (argv[i][1] == 'l' || argv[i][1] == 'A')
  393. !         number_of_files++;
  394. ! 
  395. !       i += code - 1;
  396.       }
  397. -       else
  398. -     number_of_files++;
  399.       }
  400.   
  401.     if (!number_of_files)
  402. !     fatal ("no input files", 0);
  403.   
  404.     p = file_table
  405.       = (struct file_entry *) xmalloc (number_of_files * sizeof (struct file_entry));
  406.     bzero (p, number_of_files * sizeof (struct file_entry));
  407.   
  408. !   /* Now scan again and fill in file_table.  */
  409. !   /* All options except -A and -l are ignored here.  */
  410.   
  411. !   for (i = 1; i < argc; i++)
  412. !     {
  413. !       register int code = classify_arg (argv[i]);
  414. ! 
  415. !       if (code)
  416. !     {
  417. !       char *string;
  418. !       if (code == 2)
  419. !         string = argv[i+1];
  420. !       else
  421. !         string = &argv[i][2];
  422. ! 
  423. !       if (argv[i][1] == 'A')
  424. !         {
  425. !           if (p != file_table)
  426. !         fatal ("-A specified before an input file other than the first");
  427. ! 
  428. !           p->filename = string;
  429. !           p->local_sym_name = string;
  430. !           p->just_syms_flag = 1;
  431. !           p++;
  432. !         }
  433. !       if (argv[i][1] == 'l')
  434. !         {
  435. !           p->filename = concat ("lib", string, ".a");
  436. !           p->local_sym_name = concat ("-l", string, "");
  437. !           p->search_dirs_flag = 1;
  438. !           p++;
  439. !         }
  440. !       i += code - 1;
  441. !     }
  442. !       else
  443.       {
  444. !       p->filename = argv[i];
  445. !       p->local_sym_name = argv[i];
  446.         p++;
  447.       }
  448.       }
  449.   
  450.     /* Now check some option settings for consistency.  */
  451.   
  452. ! #ifdef NMAGIC
  453. !   if ((magic == ZMAGIC || magic == NMAGIC)
  454. ! #else
  455. !   if ((magic == ZMAGIC)
  456. ! #endif
  457.         && (text_start - text_start_alignment) & (page_size - 1))
  458. !     fatal ("-T argument not multiple of page size, with sharable output", 0);
  459.   
  460.     /* Append the standard search directories to the user-specified ones.  */
  461. !   {
  462. !     int n = sizeof standard_search_dirs / sizeof standard_search_dirs[0];
  463. !     n_search_dirs += n;
  464. !     search_dirs
  465. !       = (char **) xrealloc (search_dirs, n_search_dirs * sizeof (char *));
  466. !     bcopy (standard_search_dirs, &search_dirs[n_search_dirs - n],
  467. !        n * sizeof (char *));
  468. !   }
  469.   }
  470.   
  471.   
  472. --- 1235,1468 ----
  473.     n_search_dirs = 0;
  474.     search_dirs = (char **) xmalloc (sizeof (char *));
  475.   
  476. !   /* First compute number_of_files so we know how long to make file_table.
  477. !      Also process most options completely.  */
  478.   
  479. !   while ((optc = getopt_long_only (argc, argv, SHORTOPTS, longopts, &longind))
  480. !      != EOF)
  481. !     {
  482. !       if (optc == 0)
  483. !     optc = longopts[longind].val;
  484. ! 
  485. !       switch (optc)
  486. !     {
  487. !     case '?':
  488. !       usage (0, 0);
  489. !       break;
  490. ! 
  491. !     case 1:
  492. !       /* Non-option argument. */
  493. !       number_of_files++;
  494. !       break;
  495. ! 
  496. !     case 'd':
  497. !       force_common_definition = 1;
  498. !       break;
  499. ! 
  500. !     case 'e':
  501. !       entry_symbol = getsym (optarg);
  502. !       if (!entry_symbol->defined && !entry_symbol->referenced)
  503. !         undefined_global_sym_count++;
  504. !       entry_symbol->referenced = 1;
  505. !       add_cmdline_ref (entry_symbol);
  506. !       break;
  507. ! 
  508. !     case 'l':
  509. !       number_of_files++;
  510. !       break;
  511. ! 
  512. !     case 'n':
  513. !       if (output_style && output_style != OUTPUT_READONLY_TEXT)
  514. !         fatal ("illegal combination of -n with -N, -r, or -z", (char *) 0);
  515. !       output_style = OUTPUT_READONLY_TEXT;
  516. !       break;
  517. ! 
  518. !     case 130:        /* -noinhibit-exec */
  519. !       force_executable = 1;
  520. !       break;
  521. ! 
  522. !     case 133:        /* -nostdlib */
  523. !       no_standard_dirs = 1;
  524. !       break;
  525. ! 
  526. !     case 'o':
  527. !       output_filename = optarg;
  528. !       break;
  529. ! 
  530. !     case 'r':
  531. !       if (output_style && output_style != OUTPUT_RELOCATABLE)
  532. !         fatal ("illegal combination of -r with -N, -n, or -z", (char *) 0);
  533. !       output_style = OUTPUT_RELOCATABLE;
  534. !       text_start = 0;
  535. !       break;
  536. ! 
  537. !     case 's':
  538. !       strip_symbols = STRIP_ALL;
  539. !       break;
  540. ! 
  541. !     case 't':
  542. !       trace_files = 1;
  543. !       break;
  544. ! 
  545. !     case 'u':
  546. !       {
  547. !         register symbol *sp = getsym (optarg);
  548. ! 
  549. !         if (!sp->defined && !sp->referenced)
  550. !           undefined_global_sym_count++;
  551. !         sp->referenced = 1;
  552. !         add_cmdline_ref (sp);
  553. !       }
  554. !       break;
  555. ! 
  556. !     case 'x':
  557. !       discard_locals = DISCARD_ALL;
  558. !       break;
  559. !       
  560. !     case 'y':
  561. !       {
  562. !         register symbol *sp = getsym (optarg);
  563. ! 
  564. !         sp->trace = 1;
  565. !       }
  566. !       break;
  567. ! 
  568. !     case 'z':
  569. !       if (output_style && output_style != OUTPUT_DEMAND_PAGED)
  570. !         fatal ("illegal combination of -z with -N, -n, or -r", (char *) 0);
  571. !       output_style = OUTPUT_DEMAND_PAGED;
  572. !       break;
  573. ! 
  574. !     case 'A':
  575. !       number_of_files++;
  576. !       break;
  577. ! 
  578. !     case 129:        /* -Bstatic. */
  579. !       /* Ignore. */
  580. !       break;
  581. ! 
  582. !     case 'D':
  583. !       specified_data_size = parse (optarg, "%x", "invalid argument to -D");
  584. !       break;
  585. ! 
  586. !     case 'L':
  587. !       n_search_dirs++;
  588. !       search_dirs = (char **)
  589. !         xrealloc (search_dirs, n_search_dirs * sizeof (char *));
  590. !       search_dirs[n_search_dirs - 1] = optarg;
  591. !       break;
  592. !       
  593. !     case 'M':
  594. !       write_map = 1;
  595. !       break;
  596. ! 
  597. !     case 'N':
  598. !       if (output_style && output_style != OUTPUT_WRITABLE_TEXT)
  599. !         fatal ("illegal combination of -N with -n, -r, or -z", (char *) 0);
  600. !       output_style = OUTPUT_WRITABLE_TEXT;
  601. !       break;
  602. ! 
  603. !     case 'S':
  604. !       strip_symbols = STRIP_DEBUGGER;
  605. !       break;
  606. ! 
  607. !     case 'T':
  608. !       text_start = parse (optarg, "%x", "invalid argument to -Ttext");
  609. !       T_flag_specified = 1;
  610. !       break;
  611. ! 
  612. !     case 132:        /* -Tdata addr */
  613. !       data_start = parse (optarg, "%x", "invalid argument to -Tdata");
  614. !       Tdata_flag_specified = 1;
  615. !       break;
  616. ! 
  617. !     case 'V':
  618. !       {
  619. !         struct string_list_element *new
  620. !           = (struct string_list_element *)
  621. !         xmalloc (sizeof (struct string_list_element));
  622. !         
  623. !         new->str = optarg;
  624. !         new->next = set_element_prefixes;
  625. !         set_element_prefixes = new;
  626. !       }
  627. !       break;
  628. ! 
  629. !     case 'X':
  630. !       discard_locals = DISCARD_L;
  631. !       break;
  632.       }
  633.       }
  634.   
  635.     if (!number_of_files)
  636. !     usage ("no input files", 0);
  637.   
  638.     p = file_table
  639.       = (struct file_entry *) xmalloc (number_of_files * sizeof (struct file_entry));
  640.     bzero (p, number_of_files * sizeof (struct file_entry));
  641.   
  642. !   /* Now scan again and fill in file_table.
  643. !      All options except -A and -l are ignored here.  */
  644.   
  645. !   optind = 0;            /* Reset getopt. */
  646. !   while ((optc = getopt_long_only (argc, argv, SHORTOPTS, longopts, &longind))
  647. !      != EOF)
  648. !     {
  649. !       if (optc == 0)
  650. !     optc = longopts[longind].val;
  651. ! 
  652. !       switch (optc)
  653.       {
  654. !     case 1:
  655. !       /* Non-option argument. */
  656. !       p->filename = optarg;
  657. !       p->local_sym_name = optarg;
  658. !       p++;
  659. !       break;
  660. ! 
  661. !     case 'A':
  662. !       if (p != file_table)
  663. !         usage ("-A specified before an input file other than the first");
  664. !       p->filename = optarg;
  665. !       p->local_sym_name = optarg;
  666. !       p->just_syms_flag = 1;
  667. !       p++;
  668. !       break;
  669. ! 
  670. !     case 'l':
  671. !       p->filename = concat ("lib", optarg, ".a");
  672. !       p->local_sym_name = concat ("-l", optarg, "");
  673. !       p->search_dirs_flag = 1;
  674.         p++;
  675. +       break;
  676.       }
  677.       }
  678.   
  679. +   if (!output_file_type)
  680. +     output_file_type = DEFAULT_OUTPUT_FILE_TYPE;
  681. + 
  682. +   if (!output_style)
  683. +     output_style = DEFAULT_OUTPUT_STYLE;
  684. + 
  685. + #if 0
  686. +   /* THIS CONSISTENCY CHECK BELONGS SOMEWHERE ELSE.  */
  687.     /* Now check some option settings for consistency.  */
  688.   
  689. !   if ((output_style == OUTPUT_READONLY_TEXT || output_style == OUTPUT_DEMAND_PAGED)
  690.         && (text_start - text_start_alignment) & (page_size - 1))
  691. !     usage ("-T argument not multiple of page size, with sharable output", 0);
  692. ! #endif
  693.   
  694.     /* Append the standard search directories to the user-specified ones.  */
  695. !   if (!no_standard_dirs)
  696. !     {
  697. !       int n = sizeof standard_search_dirs / sizeof standard_search_dirs[0];
  698. !       n_search_dirs += n;
  699. !       search_dirs
  700. !     = (char **) xrealloc (search_dirs, n_search_dirs * sizeof (char *));
  701. !       bcopy (standard_search_dirs, &search_dirs[n_search_dirs - n],
  702. !          n * sizeof (char *));
  703. !     }
  704.   }
  705.   
  706.   
  707. ***************
  708. *** 1252,1415 ****
  709.       }
  710.     return 0;
  711.   }
  712. - 
  713. - int parse ();
  714. - 
  715. - /* Record an option and arrange to act on it later.
  716. -    ARG should be the following command argument,
  717. -    which may or may not be used by this option.
  718. - 
  719. -    The `l' and `A' options are ignored here since they actually
  720. -    specify input files.  */
  721. - 
  722. - void
  723. - decode_option (swt, arg)
  724. -      register char *swt, *arg;
  725. - {
  726. -   /* We get Bstatic from gcc on suns.  */
  727. -   if (! strcmp (swt + 1, "Bstatic"))
  728. -     return;
  729. -   if (! strcmp (swt + 1, "Ttext"))
  730. -     {
  731. -       text_start = parse (arg, "%x", "invalid argument to -Ttext");
  732. -       T_flag_specified = 1;
  733. -       return;
  734. -     }
  735. -   if (! strcmp (swt + 1, "Tdata"))
  736. -     {
  737. -       data_start = parse (arg, "%x", "invalid argument to -Tdata");
  738. -       Tdata_flag_specified = 1;
  739. -       return;
  740. -     }
  741. -   if (! strcmp (swt + 1, "noinhibit-exec"))
  742. -     {
  743. -       force_executable = 1;
  744. -       return;
  745. -     }
  746. - 
  747. -   if (swt[2] != 0)
  748. -     arg = &swt[2];
  749. - 
  750. -   switch (swt[1])
  751. -     {
  752. -     case 'A':
  753. -       return;
  754. - 
  755. -     case 'D':
  756. -       specified_data_size = parse (arg, "%x", "invalid argument to -D");
  757. -       return;
  758. - 
  759. -     case 'd':
  760. -       force_common_definition = 1;
  761. -       return;
  762. - 
  763. -     case 'e':
  764. -       entry_symbol = getsym (arg);
  765. -       if (!entry_symbol->defined && !entry_symbol->referenced)
  766. -     undefined_global_sym_count++;
  767. -       entry_symbol->referenced = 1;
  768. -       add_cmdline_ref (entry_symbol);
  769. -       return;
  770. - 
  771. -     case 'l':
  772. -       return;
  773. - 
  774. -     case 'L':
  775. -       n_search_dirs++;
  776. -       search_dirs
  777. -     = (char **) xrealloc (search_dirs, n_search_dirs * sizeof (char *));
  778. -       search_dirs[n_search_dirs - 1] = arg;
  779. -       return;
  780. - 
  781. -     case 'M':
  782. -       write_map = 1;
  783. -       return;
  784. - 
  785. -     case 'N':
  786. -       magic = OMAGIC;
  787. -       return;
  788. - 
  789. - #ifdef NMAGIC
  790. -     case 'n':
  791. -       magic = NMAGIC;
  792. -       return;
  793. - #endif
  794. - 
  795. -     case 'o':
  796. -       output_filename = arg;
  797. -       return;
  798. - 
  799. -     case 'r':
  800. -       relocatable_output = 1;
  801. -       magic = OMAGIC;
  802. -       text_start = 0;
  803. -       return;
  804. - 
  805. -     case 'S':
  806. -       strip_symbols = STRIP_DEBUGGER;
  807. -       return;
  808. - 
  809. -     case 's':
  810. -       strip_symbols = STRIP_ALL;
  811. -       return;
  812. - 
  813. -     case 'T':
  814. -       text_start = parse (arg, "%x", "invalid argument to -T");
  815. -       T_flag_specified = 1;
  816. -       return;
  817. - 
  818. -     case 't':
  819. -       trace_files = 1;
  820. -       return;
  821. - 
  822. -     case 'u':
  823. -       {
  824. -     register symbol *sp = getsym (arg);
  825. -     if (!sp->defined && !sp->referenced)
  826. -       undefined_global_sym_count++;
  827. -     sp->referenced = 1;
  828. -     add_cmdline_ref (sp);
  829. -       }
  830. -       return;
  831. - 
  832. -     case 'V':
  833. -       {
  834. -     struct string_list_element *new
  835. -       = (struct string_list_element *)
  836. -         xmalloc (sizeof (struct string_list_element));
  837. - 
  838. -     new->str = arg;
  839. -     new->next = set_element_prefixes;
  840. -     set_element_prefixes = new;
  841. -     return;
  842. -       }
  843. - 
  844. -     case 'X':
  845. -       discard_locals = DISCARD_L;
  846. -       return;
  847. - 
  848. -     case 'x':
  849. -       discard_locals = DISCARD_ALL;
  850. -       return;
  851. - 
  852. -     case 'y':
  853. -       {
  854. -     register symbol *sp = getsym (&swt[2]);
  855. -     sp->trace = 1;
  856. -       }
  857. -       return;
  858. - 
  859. -     case 'z':
  860. -       magic = ZMAGIC;
  861. -       return;
  862. - 
  863. -     default:
  864. -       fatal ("invalid command option `%s'", swt);
  865. -     }
  866. - }
  867.   
  868. ! /** Convenient functions for operating on one or all files being */
  869. !  /** loaded.  */
  870.   void print_file_name ();
  871.   
  872.   /* Call FUNCTION on each input file entry.
  873. --- 1509,1517 ----
  874.       }
  875.     return 0;
  876.   }
  877.   
  878. ! /* Convenient functions for operating on one or all files being
  879. !    loaded.  */
  880.   void print_file_name ();
  881.   
  882.   /* Call FUNCTION on each input file entry.
  883. ***************
  884. *** 1525,1533 ****
  885.   
  886.     if (input_file) file_close ();
  887.   
  888. !   if (entry->search_dirs_flag)
  889.       {
  890. -       register char **p = search_dirs;
  891.         int i;
  892.   
  893.         for (i = 0; i < n_search_dirs; i++)
  894. --- 1627,1634 ----
  895.   
  896.     if (input_file) file_close ();
  897.   
  898. !   if (entry->search_dirs_flag && n_search_dirs)
  899.       {
  900.         int i;
  901.   
  902.         for (i = 0; i < n_search_dirs; i++)
  903. ***************
  904. *** 1790,1812 ****
  905.        int desc;
  906.        register struct file_entry *entry;
  907.   {
  908. !   register int len;
  909. !   struct exec *loc = (struct exec *) &entry->header;
  910.   
  911. !   lseek (desc, entry->starting_offset, 0);
  912. !   len = read (desc, loc, sizeof (struct exec));
  913. !   if (len != sizeof (struct exec))
  914. !     fatal_with_file ("failure reading header of ", entry);
  915. !   if (N_BADMAG (*loc))
  916. !     fatal_with_file ("bad magic number in ", entry);
  917.   
  918.     entry->header_read_flag = 1;
  919.   }
  920.   
  921.   /* Read the symbols of file ENTRY into core.
  922. !    Assume it is already open, on descriptor DESC.
  923. !    Also read the length of the string table, which follows the symbol table,
  924. !    but don't read the contents of the string table.  */
  925.   
  926.   void
  927.   read_entry_symbols (desc, entry)
  928. --- 2173,2210 ----
  929.        int desc;
  930.        register struct file_entry *entry;
  931.   {
  932. !   if (!entry->file_type)
  933. !     deduce_file_type (desc, entry);
  934.   
  935. !   switch (entry->file_type)
  936. !     {
  937. !     case IS_ARCHIVE:
  938. !     default:
  939. !       /* Should never happen. */
  940. !       abort ();
  941. ! 
  942. ! #ifdef A_OUT
  943. !     case IS_A_OUT:
  944. !       read_a_out_header (desc, entry);
  945. !       break;
  946. ! #endif
  947.   
  948. + #ifdef MACH_O
  949. +     case IS_MACH_O:
  950. +       read_mach_o_header (desc, entry);
  951. +       break;
  952. + #endif
  953. +     }
  954. + 
  955.     entry->header_read_flag = 1;
  956.   }
  957.   
  958. + #ifdef MACH_O
  959. + void translate_mach_o_symbols ();
  960. + #endif
  961. + 
  962.   /* Read the symbols of file ENTRY into core.
  963. !    Assume it is already open, on descriptor DESC.  */
  964.   
  965.   void
  966.   read_entry_symbols (desc, entry)
  967. ***************
  968. *** 1818,1839 ****
  969.     if (!entry->header_read_flag)
  970.       read_header (desc, entry);
  971.   
  972. !   entry->symbols = (struct nlist *) xmalloc (entry->header.a_syms);
  973.   
  974. !   lseek (desc, N_SYMOFF (entry->header) + entry->starting_offset, 0);
  975. !   if (entry->header.a_syms != read (desc, entry->symbols, entry->header.a_syms))
  976.       fatal_with_file ("premature end of file in symbols of ", entry);
  977.   
  978. !   lseek (desc, N_STROFF (entry->header) + entry->starting_offset, 0);
  979. !   if (sizeof str_size != read (desc, &str_size, sizeof str_size))
  980. !     fatal_with_file ("bad string table size in ", entry);
  981. ! 
  982. !   entry->string_size = str_size;
  983.   }
  984.   
  985.   /* Read the string table of file ENTRY into core.
  986. !    Assume it is already open, on descriptor DESC.
  987. !    Also record whether a GDB symbol segment follows the string table.  */
  988.   
  989.   void
  990.   read_entry_strings (desc, entry)
  991. --- 2216,2235 ----
  992.     if (!entry->header_read_flag)
  993.       read_header (desc, entry);
  994.   
  995. !   entry->symbols = (struct nlist *) xmalloc (entry->syms_size);
  996.   
  997. !   lseek (desc, entry->syms_offset + entry->starting_offset, 0);
  998. !   if (entry->syms_size != read (desc, entry->symbols, entry->syms_size))
  999.       fatal_with_file ("premature end of file in symbols of ", entry);
  1000.   
  1001. ! #ifdef MACH_O
  1002. !   if (entry->file_type == IS_MACH_O)
  1003. !     translate_mach_o_symbols (entry);
  1004. ! #endif
  1005.   }
  1006.   
  1007.   /* Read the string table of file ENTRY into core.
  1008. !    Assume it is already open, on descriptor DESC.  */
  1009.   
  1010.   void
  1011.   read_entry_strings (desc, entry)
  1012. ***************
  1013. *** 1736,1768 ****
  1014.        register struct file_entry *entry;
  1015.   {
  1016.     register int desc;
  1017. -   register int len;
  1018. -   struct exec hdr;
  1019.   
  1020.     desc = file_open (entry);
  1021.   
  1022. !   len = read (desc, &hdr, sizeof hdr);
  1023. !   if (len != sizeof hdr)
  1024. !     fatal_with_file ("failure reading header of ", entry);
  1025.   
  1026. !   if (!N_BADMAG (hdr))
  1027.       {
  1028.         read_entry_symbols (desc, entry);
  1029. !       entry->strings = (char *) alloca (entry->string_size);
  1030.         read_entry_strings (desc, entry);
  1031.         enter_file_symbols (entry);
  1032.         entry->strings = 0;
  1033.       }
  1034. -   else
  1035. -     {
  1036. -       char armag[SARMAG];
  1037. - 
  1038. -       lseek (desc, 0, 0);
  1039. -       if (SARMAG != read (desc, armag, SARMAG) || strncmp (armag, ARMAG, SARMAG))
  1040. -     fatal_with_file ("malformed input file (not rel or archive) ", entry);
  1041. -       entry->library_flag = 1;
  1042. -       search_library (desc, entry);
  1043. -     }
  1044.   
  1045.     file_close ();
  1046.   }
  1047. --- 2113,2137 ----
  1048.        register struct file_entry *entry;
  1049.   {
  1050.     register int desc;
  1051.   
  1052.     desc = file_open (entry);
  1053.   
  1054. !   if (!entry->file_type)
  1055. !     deduce_file_type (desc, entry);
  1056.   
  1057. !   if (entry->file_type == IS_ARCHIVE)
  1058. !     {
  1059. !       entry->library_flag = 1;
  1060. !       search_library (desc, entry);
  1061. !     }
  1062. !   else
  1063.       {
  1064.         read_entry_symbols (desc, entry);
  1065. !       entry->strings = (char *) alloca (entry->strs_size);
  1066.         read_entry_strings (desc, entry);
  1067.         enter_file_symbols (entry);
  1068.         entry->strings = 0;
  1069.       }
  1070.   
  1071.     file_close ();
  1072.   }
  1073. ***************
  1074. *** 1775,1782 ****
  1075.   {
  1076.     register struct nlist
  1077.       *p,
  1078. !     *end = entry->symbols + entry->header.a_syms / sizeof (struct nlist);
  1079. !   int lowest_set_vector = -1;
  1080.   
  1081.     if (trace_files) prline_file_name (entry, stderr);
  1082.   
  1083. --- 2144,2150 ----
  1084.   {
  1085.     register struct nlist
  1086.       *p,
  1087. !     *end = entry->symbols + entry->syms_size / sizeof (struct nlist);
  1088.   
  1089.     if (trace_files) prline_file_name (entry, stderr);
  1090.   
  1091. ***************
  1092. *** 1900,1907 ****
  1093.         /* Indirect symbols value should be modified to point
  1094.            a symbol being equivalenced to. */
  1095.         nlist_p->n_value
  1096.           = (unsigned int) getsym ((nlist_p + 1)->n_un.n_strx
  1097.                        + entry->strings);
  1098.         if ((symbol *) nlist_p->n_value == sp)
  1099.           {
  1100.             /* Somebody redefined a symbol to be itself.  */
  1101. --- 2268,2280 ----
  1102.         /* Indirect symbols value should be modified to point
  1103.            a symbol being equivalenced to. */
  1104.         nlist_p->n_value
  1105. + #ifndef NeXT
  1106.           = (unsigned int) getsym ((nlist_p + 1)->n_un.n_strx
  1107.                        + entry->strings);
  1108. + #else
  1109. +         /* NeXT also has indirection but they do it weirdly. */
  1110. +         = (unsigned int) getsym (nlist_p->n_value + entry->strings);
  1111. + #endif
  1112.         if ((symbol *) nlist_p->n_value == sp)
  1113.           {
  1114.             /* Somebody redefined a symbol to be itself.  */
  1115. ***************
  1116. *** 2371,2377 ****
  1117.        potentially want it.  */
  1118.         if (type & N_EXT
  1119.         && (type != (N_UNDF | N_EXT) || p->n_value
  1120. !           
  1121.   #ifdef DOLLAR_KLUDGE
  1122.              || name[1] == '$'
  1123.   #endif
  1124. --- 2742,2748 ----
  1125.        potentially want it.  */
  1126.         if (type & N_EXT
  1127.         && (type != (N_UNDF | N_EXT) || p->n_value
  1128. ! 
  1129.   #ifdef DOLLAR_KLUDGE
  1130.              || name[1] == '$'
  1131.   #endif
  1132. ***************
  1133. *** 2493,2526 ****
  1134.     /* If necessary, pad text section to full page in the file.
  1135.        Include the padding in the text segment size.  */
  1136.   
  1137. ! #ifdef NMAGIC
  1138. !   if (magic == ZMAGIC || magic == NMAGIC)
  1139. ! #else
  1140. !   if (magic == ZMAGIC)
  1141. ! #endif
  1142.       {
  1143. !       int text_end = text_size + N_TXTOFF (outheader);
  1144. !       text_pad = ((text_end + page_size - 1) & (- page_size)) - text_end;
  1145.         text_size += text_pad;
  1146.       }
  1147.   
  1148. !   outheader.a_text = text_size;
  1149. ! #ifdef sequent
  1150. !   outheader.a_text += N_ADDRADJ (outheader);
  1151. ! #endif
  1152. ! 
  1153. !   /* Make the data segment address start in memory on a suitable boundary.  */
  1154.   
  1155. !   if (! Tdata_flag_specified)
  1156. !     data_start = N_DATADDR (outheader) + text_start - N_TXTADDR (outheader);
  1157.   
  1158.     /* Make sure bss starts out aligned as much as anyone can want.  */
  1159.   
  1160. !   data_size = (data_size + sizeof(double) - 1) & ~(sizeof(double)-1);
  1161.   
  1162.     /* Set up the set element vector */
  1163.   
  1164. !   if (!relocatable_output)
  1165.       {
  1166.         /* The set sector size is the number of set elements + a word
  1167.            for each symbol for the length word at the beginning of the
  1168. --- 2872,2899 ----
  1169.     /* If necessary, pad text section to full page in the file.
  1170.        Include the padding in the text segment size.  */
  1171.   
  1172. !   if (output_style == OUTPUT_READONLY_TEXT || output_style == OUTPUT_DEMAND_PAGED)
  1173.       {
  1174. !       text_pad = ((text_size + page_size - 1) & (- page_size)) - text_size;
  1175.         text_size += text_pad;
  1176.       }
  1177.   
  1178. !   /* Now that the text_size is known, initialize the data start address;
  1179. !      this depends on text_size as well as the output file format.  */
  1180.   
  1181. !   initialize_data_start ();
  1182.   
  1183.     /* Make sure bss starts out aligned as much as anyone can want.  */
  1184. +   {
  1185. +     int new_data_size = (data_size + sizeof(double) - 1) & ~(sizeof(double)-1);
  1186.   
  1187. !     data_pad += new_data_size - data_size;
  1188. !     data_size = new_data_size;
  1189. !   }
  1190.   
  1191.     /* Set up the set element vector */
  1192.   
  1193. !   if (output_style != OUTPUT_RELOCATABLE)
  1194.       {
  1195.         /* The set sector size is the number of set elements + a word
  1196.            for each symbol for the length word at the beginning of the
  1197. ***************
  1198. *** 2556,2562 ****
  1199.       {
  1200.         /* For each symbol */
  1201.         register struct nlist *p, *next;
  1202. !       int defs = 0, com = sp->max_common_size, erred = 0;
  1203.         struct nlist *first_definition;
  1204.         for (p = sp->refs; p; p = next)
  1205.           {
  1206. --- 2929,2935 ----
  1207.       {
  1208.         /* For each symbol */
  1209.         register struct nlist *p, *next;
  1210. !       int defs = 0, com = sp->max_common_size;
  1211.         struct nlist *first_definition;
  1212.         for (p = sp->refs; p; p = next)
  1213.           {
  1214. ***************
  1215. *** 2828,2853 ****
  1216.   
  1217.     bss_size = (bss_size + sizeof(double) - 1) & ~(sizeof(double)-1);
  1218.   
  1219. !   if (end_symbol)        /* These are null if -r.  */
  1220. !     {
  1221. !       etext_symbol->value = text_size + text_start;
  1222. !       edata_symbol->value = data_start + data_size;
  1223. !       end_symbol->value = data_start + data_size + bss_size;
  1224. !     }
  1225.   
  1226.     /* Figure the data_pad now, so that it overlaps with the bss addresses.  */
  1227.   
  1228. !   if (specified_data_size && specified_data_size > data_size)
  1229. !     data_pad = specified_data_size - data_size;
  1230.   
  1231. !   if (magic == ZMAGIC)
  1232. !     data_pad = ((data_pad + data_size + page_size - 1) & (- page_size))
  1233. !                - data_size;
  1234. ! 
  1235. !   bss_size -= data_pad;
  1236. !   if (bss_size < 0) bss_size = 0;
  1237.   
  1238. !   data_size += data_pad;
  1239.   }
  1240.   
  1241.   /* Accumulate the section sizes of input file ENTRY
  1242. --- 3201,3253 ----
  1243.   
  1244.     bss_size = (bss_size + sizeof(double) - 1) & ~(sizeof(double)-1);
  1245.   
  1246. !   /* Give values to _end and friends.  */
  1247. !   {
  1248. !     int end_value = data_start + data_size + bss_size;
  1249. !     if (end_symbol)
  1250. !       end_symbol->value = end_value;
  1251. !     if (end_symbol_alt)
  1252. !       end_symbol_alt->value = end_value;
  1253. !   }
  1254. ! 
  1255. !   {
  1256. !     int etext_value = text_size + text_start;
  1257. !     if (etext_symbol)
  1258. !       etext_symbol->value = etext_value;
  1259. !     if (etext_symbol_alt)
  1260. !       etext_symbol_alt->value = etext_value;
  1261. !   }
  1262. ! 
  1263. !   {
  1264. !     int edata_value = data_start + data_size;
  1265. !     if (edata_symbol)
  1266. !       edata_symbol->value = edata_value;
  1267. !     if (edata_symbol_alt)
  1268. !       edata_symbol_alt->value = edata_value;
  1269. !   }
  1270.   
  1271.     /* Figure the data_pad now, so that it overlaps with the bss addresses.  */
  1272.   
  1273. !   {
  1274. !     /* The amount of data_pad that we are computing now.  This is the
  1275. !        part which overlaps with bss.  What was computed previously
  1276. !        goes before bss.  */
  1277. !     int data_pad_additional = 0;
  1278. !     
  1279. !     if (specified_data_size && specified_data_size > data_size)
  1280. !       data_pad_additional = specified_data_size - data_size;
  1281. ! 
  1282. !     if (output_style == OUTPUT_DEMAND_PAGED)
  1283. !       data_pad_additional =
  1284. !     ((data_pad_additional + data_size + page_size - 1) & (- page_size)) - data_size;
  1285. ! 
  1286. !     bss_size -= data_pad_additional;
  1287. !     if (bss_size < 0) bss_size = 0;
  1288.   
  1289. !     data_size += data_pad_additional;
  1290.   
  1291. !     data_pad += data_pad_additional;
  1292. !   }
  1293.   }
  1294.   
  1295.   /* Accumulate the section sizes of input file ENTRY
  1296. ***************
  1297. *** 2899,2910 ****
  1298.     current->filename = next->filename;
  1299.   
  1300.     while (++(next->sym) < (entry->symbols
  1301. !               + entry->header.a_syms/sizeof (struct nlist)))
  1302.       {
  1303.         /* n_type is a char, and N_SOL, N_EINCL and N_BINCL are > 0x80, so
  1304.          * may look negative...therefore, must mask to low bits
  1305.          */
  1306. !       switch (next->sym->n_type & 0xff) 
  1307.       {
  1308.       case N_SLINE:
  1309.         if (use_data_symbols) continue;
  1310. --- 3300,3311 ----
  1311.     current->filename = next->filename;
  1312.   
  1313.     while (++(next->sym) < (entry->symbols
  1314. !               + entry->syms_size/sizeof (struct nlist)))
  1315.       {
  1316.         /* n_type is a char, and N_SOL, N_EINCL and N_BINCL are > 0x80, so
  1317.          * may look negative...therefore, must mask to low bits
  1318.          */
  1319. !       switch (next->sym->n_type & 0xff)
  1320.       {
  1321.       case N_SLINE:
  1322.         if (use_data_symbols) continue;
  1323. ***************
  1324. *** 3023,3029 ****
  1325.     int use_data_symbols;
  1326.   
  1327.     if (next->sym)
  1328. !     use_data_symbols = (next->sym->n_type & N_TYPE) == N_DATA;
  1329.     else
  1330.       return current->line;
  1331.   
  1332. --- 3424,3430 ----
  1333.     int use_data_symbols;
  1334.   
  1335.     if (next->sym)
  1336. !     use_data_symbols = (next->sym->n_type & ~N_EXT) == N_DATA;
  1337.     else
  1338.       return current->line;
  1339.   
  1340. ***************
  1341. *** 3075,3081 ****
  1342.       *reloc_start = data_segment ? entry->datarel : entry->textrel,
  1343.       *reloc;
  1344.     int reloc_size
  1345. !     = ((data_segment ? entry->header.a_drsize : entry->header.a_trsize)
  1346.          / sizeof (struct relocation_info));
  1347.     int start_of_segment
  1348.       = (data_segment ? entry->data_start_address : entry->text_start_address);
  1349. --- 3476,3482 ----
  1350.       *reloc_start = data_segment ? entry->datarel : entry->textrel,
  1351.       *reloc;
  1352.     int reloc_size
  1353. !     = ((data_segment ? entry->data_reloc_size : entry->text_reloc_size)
  1354.          / sizeof (struct relocation_info));
  1355.     int start_of_segment
  1356.       = (data_segment ? entry->data_start_address : entry->text_start_address);
  1357. ***************
  1358. *** 3082,3091 ****
  1359.     struct nlist *start_of_syms = entry->symbols;
  1360.     struct line_debug_entry *state_pointer
  1361.       = init_debug_scan (data_segment != 0, entry);
  1362. !   register struct line_debug_entry
  1363. !     *current = state_pointer,
  1364. !     *next = state_pointer + 1,
  1365. !     *source = state_pointer + 2;
  1366.     /* Assigned to generally static values; should not be written into.  */
  1367.     char *errfmt;
  1368.     /* Assigned to alloca'd values cand copied into; should be freed
  1369. --- 3483,3489 ----
  1370.     struct nlist *start_of_syms = entry->symbols;
  1371.     struct line_debug_entry *state_pointer
  1372.       = init_debug_scan (data_segment != 0, entry);
  1373. !   register struct line_debug_entry *current = state_pointer;
  1374.     /* Assigned to generally static values; should not be written into.  */
  1375.     char *errfmt;
  1376.     /* Assigned to alloca'd values cand copied into; should be freed
  1377. ***************
  1378. *** 3307,3324 ****
  1379.   
  1380.         /* Mark as being noted by relocation warning pass.  */
  1381.         SET_BIT (nlist_bitvector, s - start_of_syms);
  1382. !       
  1383.         errfmt = 0;
  1384.         errmsg = g->warning;
  1385.         invalidate_line_number = 0;
  1386.       }
  1387. !       
  1388.   
  1389.         /* If errfmt == 0, errmsg has already been defined.  */
  1390.         if (errfmt != 0)
  1391.       {
  1392. !       errmsg = (char *) xmalloc (strlen (errfmt) + strlen (g->name) + 1);
  1393. !       sprintf (errmsg, errfmt, g->name, data_segment ? "data" : "text");
  1394.       }
  1395.   
  1396.         address_to_line (RELOC_ADDRESS (reloc) + start_of_segment,
  1397. --- 3705,3728 ----
  1398.   
  1399.         /* Mark as being noted by relocation warning pass.  */
  1400.         SET_BIT (nlist_bitvector, s - start_of_syms);
  1401. ! 
  1402.         errfmt = 0;
  1403.         errmsg = g->warning;
  1404.         invalidate_line_number = 0;
  1405.       }
  1406. ! 
  1407.   
  1408.         /* If errfmt == 0, errmsg has already been defined.  */
  1409.         if (errfmt != 0)
  1410.       {
  1411. !       char *nm;
  1412. ! 
  1413. !       if (!demangler || !(nm = (*demangler)(g->name)))
  1414. !         nm = g->name;
  1415. !       errmsg = xmalloc (strlen (errfmt) + strlen (nm) + 1);
  1416. !       sprintf (errmsg, errfmt, nm, data_segment ? "data" : "text");
  1417. !       if (nm != g->name)
  1418. !         free (nm);
  1419.       }
  1420.   
  1421.         address_to_line (RELOC_ADDRESS (reloc) + start_of_segment,
  1422. ***************
  1423. *** 3198,3204 ****
  1424.        struct file_entry *entry;
  1425.        FILE *outfile;
  1426.   {
  1427. !   int number_of_syms = entry->header.a_syms / sizeof (struct nlist);
  1428.     unsigned char *nlist_bitvector
  1429.       = (unsigned char *) alloca ((number_of_syms >> 3) + 1);
  1430.     struct line_debug_entry *text_scan, *data_scan;
  1431. --- 3609,3615 ----
  1432.        struct file_entry *entry;
  1433.        FILE *outfile;
  1434.   {
  1435. !   int number_of_syms = entry->syms_size / sizeof (struct nlist);
  1436.     unsigned char *nlist_bitvector
  1437.       = (unsigned char *) alloca ((number_of_syms >> 3) + 1);
  1438.     struct line_debug_entry *text_scan, *data_scan;
  1439. ***************
  1440. *** 3426,3432 ****
  1441.       {
  1442.         if (g->undef_refs >= MAX_UREFS_PRINTED)
  1443.           continue;
  1444. !       
  1445.         if (++(g->undef_refs) == MAX_UREFS_PRINTED)
  1446.           errfmt = "More undefined \"%s\" refs follow";
  1447.         else
  1448. --- 3837,3843 ----
  1449.       {
  1450.         if (g->undef_refs >= MAX_UREFS_PRINTED)
  1451.           continue;
  1452. ! 
  1453.         if (++(g->undef_refs) == MAX_UREFS_PRINTED)
  1454.           errfmt = "More undefined \"%s\" refs follow";
  1455.         else
  1456. ***************
  1457. *** 3449,3464 ****
  1458.       }
  1459.         else
  1460.       continue;
  1461. !       
  1462.         if (line_number == -1)
  1463. !     fprintf (outfile, "%s: ", entry->filename);
  1464.         else
  1465. !     fprintf (outfile, "%s:%d: ", file_name, line_number);
  1466.   
  1467.         if (dont_allow_symbol_name)
  1468.       fprintf (outfile, "%s", errfmt);
  1469.         else
  1470. !     fprintf (outfile, errfmt, g->name);
  1471.   
  1472.         fputc ('\n', outfile);
  1473.       }
  1474. --- 3860,3892 ----
  1475.       }
  1476.         else
  1477.       continue;
  1478. ! 
  1479.         if (line_number == -1)
  1480. !     {
  1481. !       print_file_name (entry, outfile);
  1482. !       fprintf (outfile, ": ");
  1483. !     }
  1484.         else
  1485. !     {
  1486. !       fprintf (outfile, "%s:%d (", file_name, line_number);
  1487. !       print_file_name (entry, outfile);
  1488. !       fprintf (outfile, "): ");
  1489. !     }
  1490.   
  1491.         if (dont_allow_symbol_name)
  1492.       fprintf (outfile, "%s", errfmt);
  1493.         else
  1494. !     {
  1495. !       char *nm;
  1496. ! 
  1497. !       if (!demangler || !(nm = (*demangler)(g->name)))
  1498. !         fprintf (outfile, errfmt, g->name);
  1499. !       else
  1500. !         {
  1501. !           fprintf (outfile, errfmt, nm);
  1502. !           free (nm);
  1503. !         }
  1504. !     }
  1505.   
  1506.         fputc ('\n', outfile);
  1507.       }
  1508. ***************
  1509. *** 3348,3408 ****
  1510.       make_executable = 0;
  1511.   }
  1512.   
  1513. ! /* Write the output file */
  1514. ! 
  1515. ! void
  1516. ! write_output ()
  1517. ! {
  1518. !   struct stat statbuf;
  1519. !   int filemode;
  1520. ! 
  1521. !   outdesc = open (output_filename, O_WRONLY | O_CREAT | O_TRUNC, 0666);
  1522. !   if (outdesc < 0) perror_name (output_filename);
  1523.   
  1524. !   if (fstat (outdesc, &statbuf) < 0)
  1525. !     perror_name (output_filename);
  1526.   
  1527. !   filemode = statbuf.st_mode;
  1528.   
  1529. !   chmod (output_filename, filemode & ~0111);
  1530.   
  1531. !   /* Output the a.out header.  */
  1532. !   write_header ();
  1533.   
  1534. !   /* Output the text and data segments, relocating as we go.  */
  1535. !   write_text ();
  1536. !   write_data ();
  1537.   
  1538. !   /* Output the merged relocation info, if requested with `-r'.  */
  1539. !   if (relocatable_output)
  1540. !     write_rel ();
  1541.   
  1542. !   /* Output the symbol table (both globals and locals).  */
  1543. !   write_syms ();
  1544.   
  1545. !   /* Copy any GDB symbol segments from input files.  */
  1546. !   write_symsegs ();
  1547.   
  1548. !   close (outdesc);
  1549.   
  1550. !   if (chmod (output_filename, filemode | 0111) == -1)
  1551. !     perror_name (output_filename);
  1552.   }
  1553. ! 
  1554. ! void modify_location (), perform_relocation (), copy_text (), copy_data ();
  1555.   
  1556.   void
  1557. ! write_header ()
  1558.   {
  1559. -   N_SET_MAGIC (outheader, magic);
  1560.     outheader.a_text = text_size;
  1561.   #ifdef sequent
  1562.     outheader.a_text += N_ADDRADJ (outheader);
  1563.   #endif
  1564.     outheader.a_data = data_size;
  1565.     outheader.a_bss = bss_size;
  1566.     outheader.a_entry = (entry_symbol ? entry_symbol->value
  1567. !                : text_start + entry_offset);
  1568.   #ifdef COFF_ENCAPSULATE
  1569.     if (need_coff_header)
  1570.       {
  1571. --- 3774,3877 ----
  1572.       make_executable = 0;
  1573.   }
  1574.   
  1575. ! #ifdef A_OUT
  1576.   
  1577. ! /* Stuff pertaining to creating a.out files. */
  1578.   
  1579. ! /* The a.out header. */
  1580.   
  1581. ! struct exec outheader;
  1582.   
  1583. ! #ifdef COFF_ENCAPSULATE
  1584. ! int need_coff_header;
  1585. ! struct coffheader coffheader;
  1586. ! #endif
  1587.   
  1588. ! /* Compute text_start and text_header_size for an a.out file.  */
  1589.   
  1590. ! void
  1591. ! initialize_a_out_text_start ()
  1592. ! {
  1593. !   int magic;
  1594.   
  1595. !   switch (output_style)
  1596. !     {
  1597. !     case OUTPUT_RELOCATABLE:
  1598. !     case OUTPUT_WRITABLE_TEXT:
  1599. !       magic = OMAGIC;
  1600. !       break;
  1601. !     case OUTPUT_READONLY_TEXT:
  1602. ! #ifdef NMAGIC
  1603. !       magic = NMAGIC;
  1604. !       break;
  1605. ! #endif
  1606. !     case OUTPUT_DEMAND_PAGED:
  1607. !       magic = ZMAGIC;
  1608. !       break;
  1609. !     default:
  1610. !       fatal ("unknown output style found (bug in ld)", (char *) 0);
  1611. !       break;
  1612. !     }
  1613.   
  1614. !   /* Determine whether to count the header as part of
  1615. !      the text size, and initialize the text size accordingly.
  1616. !      This depends on the kind of system and on the output format selected.  */
  1617. !   N_SET_MAGIC (outheader, magic);
  1618. ! #ifdef INITIALIZE_HEADER
  1619. !   INITIALIZE_HEADER;
  1620. ! #endif
  1621.   
  1622. !   text_header_size = sizeof (struct exec);
  1623. ! #ifdef COFF_ENCAPSULATE
  1624. !   /* Don't write the coff header for the output of ld -A (since
  1625. !      it is not executable by the kernel anyway).  */
  1626. !   if (output_style != OUTPUT_RELOCATABLE && !file_table[0].just_syms_flag)
  1627. !     {
  1628. !       need_coff_header = 1;
  1629. !       /* set this flag now, since it will change the values of N_TXTOFF, etc */
  1630. !       N_SET_FLAGS (outheader, N_FLAGS_COFF_ENCAPSULATE);
  1631. !       text_header_size += sizeof (struct coffheader);
  1632. !     }
  1633. ! #endif
  1634. !   if (text_header_size <= N_TXTOFF (outheader))
  1635. !     text_header_size = 0;
  1636. !   else
  1637. !     text_header_size -= N_TXTOFF (outheader);
  1638. ! 
  1639. ! #ifdef _N_BASEADDR
  1640. !   /* SunOS 4.1 N_TXTADDR depends on the value of outheader.a_entry. */
  1641. !   outheader.a_entry = N_PAGSIZ(outheader);
  1642. ! #endif
  1643.   
  1644. !   if (!T_flag_specified && output_style != OUTPUT_RELOCATABLE)
  1645. !     text_start = N_TXTADDR (outheader);
  1646.   }
  1647. ! 
  1648. ! /* Compute data_start once text_size is known. */
  1649.   
  1650.   void
  1651. ! initialize_a_out_data_start ()
  1652.   {
  1653.     outheader.a_text = text_size;
  1654.   #ifdef sequent
  1655.     outheader.a_text += N_ADDRADJ (outheader);
  1656. +   if (entry_symbol == 0)
  1657. +     entry_symbol = getsym ("start");
  1658.   #endif
  1659. +   if (! Tdata_flag_specified)
  1660. +     data_start = N_DATADDR (outheader) + text_start - N_TXTADDR (outheader);
  1661. + }
  1662. + 
  1663. + /* Compute offsets of various pieces of the a.out output file.  */
  1664. + 
  1665. + void
  1666. + compute_a_out_section_offsets ()
  1667. + {
  1668.     outheader.a_data = data_size;
  1669.     outheader.a_bss = bss_size;
  1670.     outheader.a_entry = (entry_symbol ? entry_symbol->value
  1671. !                : text_start + text_header_size);
  1672. ! 
  1673.   #ifdef COFF_ENCAPSULATE
  1674.     if (need_coff_header)
  1675.       {
  1676. ***************
  1677. *** 3665,3674 ****
  1678.         outheader.a_drsize = 0;
  1679.       }
  1680.   
  1681.   #ifdef COFF_ENCAPSULATE
  1682.     if (need_coff_header)
  1683.       mywrite (&coffheader, sizeof coffheader, 1, outdesc);
  1684.   #endif
  1685.     mywrite (&outheader, sizeof (struct exec), 1, outdesc);
  1686.   
  1687.     /* Output whatever padding is required in the executable file
  1688. --- 4134,4181 ----
  1689.         outheader.a_drsize = 0;
  1690.       }
  1691.   
  1692. +   /* Initialize the various file offsets.  */
  1693. + 
  1694. +   output_text_offset = N_TXTOFF (outheader);
  1695. + #ifdef N_DATOFF
  1696. +   output_data_offset = N_DATOFF (outheader);
  1697. + #else
  1698. +   output_data_offset = output_text_offset + text_size;
  1699. + #endif
  1700. + #ifdef N_TRELOFF
  1701. +   output_trel_offset = N_TRELOFF (outheader);
  1702. + #else
  1703. +   output_trel_offset = output_data_offset + data_size;
  1704. + #endif
  1705. + #ifdef N_DRELOFF
  1706. +   output_drel_offset = N_DRELOFF (outheader);
  1707. + #else
  1708. +   output_drel_offset = output_trel_offset + text_reloc_size;
  1709. + #endif
  1710. +   output_syms_offset = N_SYMOFF (outheader);
  1711. +   output_strs_offset = N_STROFF (outheader);
  1712. + }
  1713. + 
  1714. + /* Compute more section offsets once the size of the string table is known.  */
  1715. + 
  1716. + void
  1717. + compute_more_a_out_section_offsets ()
  1718. + {
  1719. +   output_symseg_offset = output_strs_offset + output_strs_size;
  1720. + }
  1721. + 
  1722. + /* Write the a.out header once everything else is known.  */
  1723. + 
  1724. + void
  1725. + write_a_out_header ()
  1726. + {
  1727. +   lseek (outdesc, 0L, 0);
  1728. + 
  1729.   #ifdef COFF_ENCAPSULATE
  1730.     if (need_coff_header)
  1731.       mywrite (&coffheader, sizeof coffheader, 1, outdesc);
  1732.   #endif
  1733. + 
  1734.     mywrite (&outheader, sizeof (struct exec), 1, outdesc);
  1735.   
  1736.     /* Output whatever padding is required in the executable file
  1737. ***************
  1738. *** 3740,3755 ****
  1739.   
  1740.     if (!entry->datarel)
  1741.       {
  1742. !       reloc = (struct relocation_info *) xmalloc (entry->header.a_drsize);
  1743.         if (desc == -1) desc = file_open (entry);
  1744. !       lseek (desc,
  1745. !          text_offset (entry) + entry->header.a_text
  1746. !          + entry->header.a_data + entry->header.a_trsize,
  1747. !          L_SET);
  1748. !       if (entry->header.a_drsize != read (desc, reloc, entry->header.a_drsize))
  1749.       fatal_with_file ("premature eof in data relocation of ", entry);
  1750.         entry->datarel = reloc;
  1751.       }
  1752.   }
  1753.   
  1754.   /* Read the text segment contents of ENTRY, relocate them,
  1755. --- 4865,4887 ----
  1756.   
  1757.     if (!entry->datarel)
  1758.       {
  1759. !       reloc = (struct relocation_info *) xmalloc (entry->data_reloc_size);
  1760.         if (desc == -1) desc = file_open (entry);
  1761. !       lseek (desc, entry->starting_offset + entry->data_reloc_offset, L_SET);
  1762. !       if (entry->data_reloc_size != read (desc, reloc, entry->data_reloc_size))
  1763.       fatal_with_file ("premature eof in data relocation of ", entry);
  1764.         entry->datarel = reloc;
  1765.       }
  1766. + 
  1767. + #ifdef MACH_O
  1768. +   if (entry->file_type == IS_MACH_O)
  1769. +     {
  1770. +       translate_mach_o_relocation (entry, entry->textrel,
  1771. +                    entry->text_reloc_size / sizeof (struct relocation_info));
  1772. +       translate_mach_o_relocation (entry, entry->datarel,
  1773. +                    entry->data_reloc_size / sizeof (struct relocation_info));
  1774. +     }
  1775. + #endif
  1776.   }
  1777.   
  1778.   /* Read the text segment contents of ENTRY, relocate them,
  1779. ***************
  1780. *** 3638,3664 ****
  1781.       }
  1782.     else
  1783.       {
  1784. !       reloc = (struct relocation_info *) alloca (entry->header.a_trsize);
  1785. !       lseek (desc, text_offset (entry) + entry->header.a_text + entry->header.a_data, 0);
  1786. !       if (entry->header.a_trsize != read (desc, reloc, entry->header.a_trsize))
  1787.       fatal_with_file ("premature eof in text relocation of ", entry);
  1788.       }
  1789.   
  1790.     /* Read the text section into core.  */
  1791.   
  1792. !   lseek (desc, text_offset (entry), 0);
  1793. !   if (entry->header.a_text != read (desc, bytes, entry->header.a_text))
  1794.       fatal_with_file ("premature eof in text section of ", entry);
  1795.   
  1796. - 
  1797.     /* Relocate the text according to the text relocation.  */
  1798.   
  1799. !   perform_relocation (bytes, entry->text_start_address, entry->header.a_text,
  1800. !               reloc, entry->header.a_trsize, entry);
  1801.   
  1802.     /* Write the relocated text to the output file.  */
  1803.   
  1804. !   mywrite (bytes, 1, entry->header.a_text, outdesc);
  1805.   }
  1806.   
  1807.   /* Relocate the data segment of each input file
  1808. --- 4770,4800 ----
  1809.       }
  1810.     else
  1811.       {
  1812. !       reloc = (struct relocation_info *) alloca (entry->text_reloc_size);
  1813. !       lseek (desc, entry->starting_offset + entry->text_reloc_offset, L_SET);
  1814. !       if (entry->text_reloc_size != read (desc, reloc, entry->text_reloc_size))
  1815.       fatal_with_file ("premature eof in text relocation of ", entry);
  1816. + #ifdef MACH_O
  1817. +       if (entry->file_type == IS_MACH_O)
  1818. +     translate_mach_o_relocation (entry, reloc,
  1819. +                      entry->text_reloc_size / sizeof (struct relocation_info));
  1820. + #endif
  1821.       }
  1822.   
  1823.     /* Read the text section into core.  */
  1824.   
  1825. !   lseek (desc, entry->starting_offset + entry->text_offset, L_SET);
  1826. !   if (entry->text_size != read (desc, bytes, entry->text_size))
  1827.       fatal_with_file ("premature eof in text section of ", entry);
  1828.   
  1829.     /* Relocate the text according to the text relocation.  */
  1830.   
  1831. !   perform_relocation (bytes, entry->text_start_address - entry->orig_text_address,
  1832. !               entry->text_size, reloc, entry->text_reloc_size, entry);
  1833.   
  1834.     /* Write the relocated text to the output file.  */
  1835.   
  1836. !   mywrite (bytes, 1, entry->text_size, outdesc);
  1837.   }
  1838.   
  1839.   /* Relocate the data segment of each input file
  1840. ***************
  1841. *** 3723,3744 ****
  1842.       }
  1843.     else
  1844.       {
  1845. !       reloc = (struct relocation_info *) alloca (entry->header.a_drsize);
  1846. !       lseek (desc, text_offset (entry) + entry->header.a_text
  1847. !          + entry->header.a_data + entry->header.a_trsize,
  1848. !          0);
  1849. !       if (entry->header.a_drsize != read (desc, reloc, entry->header.a_drsize))
  1850.       fatal_with_file ("premature eof in data relocation of ", entry);
  1851.       }
  1852.   
  1853. !   lseek (desc, text_offset (entry) + entry->header.a_text, 0);
  1854. !   if (entry->header.a_data != read (desc, bytes, entry->header.a_data))
  1855.       fatal_with_file ("premature eof in data section of ", entry);
  1856.   
  1857. !   perform_relocation (bytes, entry->data_start_address - entry->header.a_text,
  1858. !               entry->header.a_data, reloc, entry->header.a_drsize, entry);
  1859.   
  1860. !   mywrite (bytes, 1, entry->header.a_data, outdesc);
  1861.   }
  1862.   
  1863.   /* Relocate ENTRY's text or data section contents.
  1864. --- 4861,4885 ----
  1865.       }
  1866.     else
  1867.       {
  1868. !       reloc = (struct relocation_info *) alloca (entry->data_reloc_size);
  1869. !       lseek (desc, entry->starting_offset + entry->data_reloc_offset, L_SET);
  1870. !       if (entry->data_reloc_size != read (desc, reloc, entry->data_reloc_size))
  1871.       fatal_with_file ("premature eof in data relocation of ", entry);
  1872. + #ifdef MACH_O
  1873. +       if (entry->file_type == IS_MACH_O)
  1874. +     translate_mach_o_relocation (entry, reloc,
  1875. +                      entry->data_reloc_size / sizeof (struct relocation_info));
  1876. + #endif
  1877.       }
  1878.   
  1879. !   lseek (desc, entry->starting_offset + entry->data_offset, L_SET);
  1880. !   if (entry->data_size != read (desc, bytes, entry->data_size))
  1881.       fatal_with_file ("premature eof in data section of ", entry);
  1882.   
  1883. !   perform_relocation (bytes, entry->data_start_address - entry->orig_data_address,
  1884. !               entry->data_size, reloc, entry->data_reloc_size, entry);
  1885.   
  1886. !   mywrite (bytes, 1, entry->data_size, outdesc);
  1887.   }
  1888.   
  1889.   /* Relocate ENTRY's text or data section contents.
  1890. ***************
  1891. *** 4044,4049 ****
  1892.         break;
  1893.   
  1894.       case 2:
  1895.         if (RELOC_MEMORY_SUB_P(p))
  1896.           relocation -= mask & *(long *) (data + addr);
  1897.         else if (RELOC_MEMORY_ADD_P(p))
  1898. --- 5179,5200 ----
  1899.         break;
  1900.   
  1901.       case 2:
  1902. + #ifdef CROSS_LINKER
  1903. +       /* This is necessary if the host has stricter alignment
  1904. +          than the target.  Too slow to use all the time.
  1905. +          Also doesn't deal with differing byte-order.  */
  1906. +       {
  1907. +         /* Thing to relocate.  */
  1908. +         long thing;
  1909. +         bcopy (data + addr, &thing, sizeof (thing));
  1910. +         if (RELOC_MEMORY_SUB_P (p))
  1911. +           relocation -= mask & thing;
  1912. +         else if (RELOC_MEMORY_ADD_P (p))
  1913. +           relocation += mask & thing;
  1914. +         thing = (thing & ~mask) | relocation;
  1915. +         bcopy (&thing, data + addr, sizeof (thing));
  1916. +       }
  1917. + #else /* not CROSS_LINKER */
  1918.         if (RELOC_MEMORY_SUB_P(p))
  1919.           relocation -= mask & *(long *) (data + addr);
  1920.         else if (RELOC_MEMORY_ADD_P(p))
  1921. ***************
  1922. *** 4050,4055 ****
  1923.           relocation += mask & *(long *) (data + addr);
  1924.         *(long *) (data + addr) &= ~mask;
  1925.         *(long *) (data + addr) |= relocation;
  1926.         break;
  1927.   
  1928.       default:
  1929. --- 5201,5207 ----
  1930.           relocation += mask & *(long *) (data + addr);
  1931.         *(long *) (data + addr) &= ~mask;
  1932.         *(long *) (data + addr) |= relocation;
  1933. + #endif /* not CROSS_LINKER */
  1934.         break;
  1935.   
  1936.       default:
  1937. ***************
  1938. *** 4050,4063 ****
  1939.         else
  1940.           /* Debugger symbols come first, so have to start this
  1941.              after them.  */
  1942.             RELOC_SYMBOL(p) = (symptr->def_count + nsyms
  1943.                    - defined_global_sym_count
  1944.                    - undefined_global_sym_count
  1945.                    - global_indirect_count);
  1946.       }
  1947.         p++;
  1948.       }
  1949. !   mywrite (entry->textrel, 1, entry->header.a_trsize, outdesc);
  1950.   }
  1951.   
  1952.   void
  1953. --- 5211,5237 ----
  1954.         else
  1955.           /* Debugger symbols come first, so have to start this
  1956.              after them.  */
  1957. + #ifndef NeXT
  1958.             RELOC_SYMBOL(p) = (symptr->def_count + nsyms
  1959.                    - defined_global_sym_count
  1960.                    - undefined_global_sym_count
  1961.                    - global_indirect_count);
  1962. + #else
  1963. +           RELOC_SYMBOL(p) = (symptr->def_count + nsyms
  1964. +                  - defined_global_sym_count
  1965. +                  - undefined_global_sym_count);
  1966. + #endif
  1967.       }
  1968.         p++;
  1969.       }
  1970. ! 
  1971. ! #ifdef MACH_O
  1972. !   if (output_file_type == IS_MACH_O)
  1973. !     generate_mach_o_relocations(entry->textrel,
  1974. !                 entry->text_reloc_size / sizeof (struct relocation_info));
  1975. ! #endif
  1976. ! 
  1977. !   mywrite (entry->textrel, 1, entry->text_reloc_size, outdesc);
  1978.   }
  1979.   
  1980.   void
  1981. ***************
  1982. *** 4113,4139 ****
  1983.            + nsyms - defined_global_sym_count
  1984.            - undefined_global_sym_count
  1985.            - global_indirect_count);
  1986.       }
  1987.         p++;
  1988.       }
  1989. !   mywrite (entry->datarel, 1, entry->header.a_drsize, outdesc);
  1990.   }
  1991.   
  1992.   void write_file_syms ();
  1993.   void write_string_table ();
  1994.   
  1995. - /* Offsets and current lengths of symbol and string tables in output file. */
  1996. - 
  1997. - int symbol_table_offset;
  1998. - int symbol_table_len;
  1999. - 
  2000. - /* Address in output file where string table starts.  */
  2001. - int string_table_offset;
  2002. - 
  2003. - /* Offset within string table
  2004. -    where the strings in `strtab_vector' should be written.  */
  2005. - int string_table_len;
  2006. - 
  2007.   /* Total size of string table strings allocated so far,
  2008.      including strings in `strtab_vector'.  */
  2009.   int strtab_size;
  2010. --- 5291,5321 ----
  2011.            + nsyms - defined_global_sym_count
  2012.            - undefined_global_sym_count
  2013.            - global_indirect_count);
  2014. + #else
  2015. +         RELOC_SYMBOL(p)
  2016. +           = (((symbol *)
  2017. +           (((struct nlist *)
  2018. +             (((char *)entry->symbols) + symindex))
  2019. +            ->n_un.n_name))
  2020. +          ->def_count
  2021. +          + nsyms - defined_global_sym_count
  2022. +          - undefined_global_sym_count);
  2023. + #endif
  2024.       }
  2025.         p++;
  2026.       }
  2027. ! #ifdef MACH_O
  2028. !   if (output_file_type == IS_MACH_O)
  2029. !     generate_mach_o_relocations(entry->datarel,
  2030. !                 entry->data_reloc_size / sizeof (struct relocation_info));
  2031. ! #endif
  2032. ! 
  2033. !   mywrite (entry->datarel, 1, entry->data_reloc_size, outdesc);
  2034.   }
  2035.   
  2036.   void write_file_syms ();
  2037.   void write_string_table ();
  2038.   
  2039.   /* Total size of string table strings allocated so far,
  2040.      including strings in `strtab_vector'.  */
  2041.   int strtab_size;
  2042. ***************
  2043. *** 4306,4342 ****
  2044.           *bufp++ = nl;
  2045.           syms_written++;
  2046.           if (nl.n_type == (N_INDR | N_EXT))
  2047.             {
  2048.           struct nlist xtra_ref;
  2049.           xtra_ref.n_type == N_EXT | N_UNDF;
  2050.           xtra_ref.n_un.n_strx
  2051.             = assign_string_table_index (((symbol *) sp->value)->name);
  2052.           xtra_ref.n_other = 0;
  2053.           xtra_ref.n_desc = 0;
  2054.           xtra_ref.n_value = 0;
  2055.           *bufp++ = xtra_ref;
  2056.           syms_written++;
  2057.             }
  2058.         }
  2059.         }
  2060.   
  2061.     /* Output the buffer full of `struct nlist's.  */
  2062.   
  2063. !   lseek (outdesc, symbol_table_offset + symbol_table_len, 0);
  2064.     mywrite (buf, sizeof (struct nlist), bufp - buf, outdesc);
  2065. !   symbol_table_len += sizeof (struct nlist) * (bufp - buf);
  2066.   
  2067.     if (syms_written != nsyms)
  2068.       fatal ("internal error: wrong number of symbols written into output file", 0);
  2069.   
  2070. !   if (symbol_table_offset + symbol_table_len != string_table_offset)
  2071. !     fatal ("internal error: inconsistent symbol table length", 0);
  2072.   
  2073. !   /* Now the total string table size is known, so write it.
  2074. !      We are already positioned at the right place in the file.  */
  2075.   
  2076. -   mywrite (&strtab_size, sizeof (int), 1, outdesc);  /* we're at right place */
  2077. - 
  2078.     /* Write the strings for the global symbols.  */
  2079.   
  2080.     write_string_table ();
  2081. --- 5496,5543 ----
  2082.           *bufp++ = nl;
  2083.           syms_written++;
  2084.           if (nl.n_type == (N_INDR | N_EXT))
  2085. + #ifndef NeXT
  2086.             {
  2087.           struct nlist xtra_ref;
  2088.           xtra_ref.n_type == N_EXT | N_UNDF;
  2089.           xtra_ref.n_un.n_strx
  2090.             = assign_string_table_index (((symbol *) sp->value)->name);
  2091. + #ifdef N_SECT
  2092. +         xtra_ref.n_sect = 0;
  2093. + #else
  2094.           xtra_ref.n_other = 0;
  2095. + #endif
  2096.           xtra_ref.n_desc = 0;
  2097.           xtra_ref.n_value = 0;
  2098.           *bufp++ = xtra_ref;
  2099.           syms_written++;
  2100.             }
  2101. + #else
  2102. +         nl.n_value = assign_string_table_index (((symbol *) sp->value)->name);
  2103. + #endif
  2104.         }
  2105.         }
  2106.   
  2107. + #ifdef MACH_O
  2108. +   if (output_file_type == IS_MACH_O)
  2109. +     generate_mach_o_symbols(buf, bufp - buf);
  2110. + #endif
  2111. + 
  2112.     /* Output the buffer full of `struct nlist's.  */
  2113.   
  2114. !   lseek (outdesc, output_syms_offset + output_syms_size, 0);
  2115.     mywrite (buf, sizeof (struct nlist), bufp - buf, outdesc);
  2116. !   output_syms_size += sizeof (struct nlist) * (bufp - buf);
  2117.   
  2118.     if (syms_written != nsyms)
  2119.       fatal ("internal error: wrong number of symbols written into output file", 0);
  2120.   
  2121. !   /* Now the total string table size is known, so write it into the
  2122. !      first word of the string table.  */
  2123.   
  2124. !   lseek (outdesc, output_strs_offset, 0);
  2125. !   mywrite (&strtab_size, sizeof (int), 1, outdesc);
  2126.   
  2127.     /* Write the strings for the global symbols.  */
  2128.   
  2129.     write_string_table ();
  2130. ***************
  2131. *** 4436,4446 ****
  2132.       }
  2133.       }
  2134.   
  2135.     /* All the symbols are now in BUF; write them.  */
  2136.   
  2137. !   lseek (outdesc, symbol_table_offset + symbol_table_len, 0);
  2138.     mywrite (buf, sizeof (struct nlist), bufp - buf, outdesc);
  2139. !   symbol_table_len += sizeof (struct nlist) * (bufp - buf);
  2140.   
  2141.     /* Write the string-table data for the symbols just written,
  2142.        using the data in vectors `strtab_vector' and `strtab_lens'.  */
  2143. --- 5641,5656 ----
  2144.       }
  2145.       }
  2146.   
  2147. + #ifdef MACH_O
  2148. +   if (output_file_type == IS_MACH_O)
  2149. +     generate_mach_o_symbols(buf, bufp - buf);
  2150. + #endif
  2151. + 
  2152.     /* All the symbols are now in BUF; write them.  */
  2153.   
  2154. !   lseek (outdesc, output_syms_offset + output_syms_size, 0);
  2155.     mywrite (buf, sizeof (struct nlist), bufp - buf, outdesc);
  2156. !   output_syms_size += sizeof (struct nlist) * (bufp - buf);
  2157.   
  2158.     /* Write the string-table data for the symbols just written,
  2159.        using the data in vectors `strtab_vector' and `strtab_lens'.  */
  2160. ***************
  2161. *** 4639,4715 ****
  2162.   
  2163.     /* Copy the rest of the symbol segment unchanged.  */
  2164.   
  2165. !   if (entry->superfile)
  2166. !     {
  2167. !       /* Library member: number of bytes to copy is determined
  2168. !      from the member's total size.  */
  2169. ! 
  2170. !       int total = entry->total_size - entry->symseg_offset - sizeof root;
  2171.   
  2172. !       while (total > 0)
  2173. !     {
  2174. !       len = read (indesc, buffer, min (sizeof buffer, total));
  2175. ! 
  2176. !       if (len != min (sizeof buffer, total))
  2177. !         fatal_with_file ("premature end of file in symbol segment of ", entry);
  2178. !       total -= len;
  2179. !       mywrite (buffer, len, 1, outdesc);
  2180. !     }
  2181. !     }
  2182. !   else
  2183. !     {
  2184. !       /* A separate file: copy until end of file.  */
  2185. ! 
  2186. !       while (len = read (indesc, buffer, sizeof buffer))
  2187. !     {
  2188. !       mywrite (buffer, len, 1, outdesc);
  2189. !       if (len < sizeof buffer)
  2190. !         break;
  2191. !     }
  2192.       }
  2193.   
  2194.     file_close ();
  2195.   }
  2196.   
  2197.   /* Create the symbol table entries for `etext', `edata' and `end'.  */
  2198.   
  2199.   void
  2200.   symtab_init ()
  2201.   {
  2202. ! #ifndef nounderscore
  2203. !   edata_symbol = getsym ("_edata");
  2204. !   etext_symbol = getsym ("_etext");
  2205. !   end_symbol = getsym ("_end");
  2206. ! #else
  2207. !   edata_symbol = getsym ("edata");
  2208. !   etext_symbol = getsym ("etext");
  2209. !   end_symbol = getsym ("end");
  2210. ! #endif
  2211.   
  2212.   #ifdef sun
  2213.     {
  2214. !     symbol *dynamic_symbol = getsym ("__DYNAMIC");
  2215. !     dynamic_symbol->defined = N_ABS | N_EXT;
  2216. !     dynamic_symbol->referenced = 1;
  2217. !     dynamic_symbol->value = 0;
  2218.     }
  2219. ! #endif
  2220. ! #ifdef sequent
  2221. !   {
  2222. !     symbol *_387_flt_symbol = getsym ("_387_flt");
  2223. !     _387_flt_symbol->defined = N_ABS | N_EXT;
  2224. !     _387_flt_symbol->referenced = 1;
  2225. !     _387_flt_symbol->value = 0;
  2226. !   }
  2227. ! #endif
  2228. ! 
  2229. !   edata_symbol->defined = N_DATA | N_EXT;
  2230. !   etext_symbol->defined = N_TEXT | N_EXT;
  2231. !   end_symbol->defined = N_BSS | N_EXT;
  2232. ! 
  2233. !   edata_symbol->referenced = 1;
  2234. !   etext_symbol->referenced = 1;
  2235. !   end_symbol->referenced = 1;
  2236.   }
  2237.   
  2238.   /* Compute the hash code for symbol name KEY.  */
  2239. --- 5850,5947 ----
  2240.   
  2241.     /* Copy the rest of the symbol segment unchanged.  */
  2242.   
  2243. !   total = entry->symseg_size - sizeof root;
  2244.   
  2245. !   while (total > 0)
  2246. !     {
  2247. !       len = read (indesc, buffer, min (sizeof buffer, total));
  2248. ! 
  2249. !       if (len != min (sizeof buffer, total))
  2250. !     fatal_with_file ("premature end of file in symbol segment of ", entry);
  2251. !       total -= len;
  2252. !       mywrite (buffer, len, 1, outdesc);
  2253.       }
  2254.   
  2255.     file_close ();
  2256.   }
  2257.   
  2258. + /* Define a special symbol (etext, edata, or end).  NAME is the
  2259. +    name of the symbol, with a leading underscore (whether or not this
  2260. +    system uses such underscores).  TYPE is its type (e.g. N_DATA | N_EXT).
  2261. +    Store a symbol * for the symbol in *SYM if SYM is non-NULL.  */
  2262. + static void
  2263. + symbol_define (name, type, sym)
  2264. +      /* const */ char *name;
  2265. +      int type;
  2266. +      symbol **sym;
  2267. + {
  2268. +   symbol *thesym;
  2269. + 
  2270. + #if defined(nounderscore)
  2271. +   /* Skip the leading underscore.  */
  2272. +   name++;
  2273. + #endif
  2274. + 
  2275. +   thesym = getsym (name);
  2276. +   if (thesym->defined)
  2277. +     {
  2278. +       /* The symbol is defined in some input file.  Don't mess with it.  */
  2279. +       if (sym)
  2280. +     *sym = 0;
  2281. +     }
  2282. +   else
  2283. +     {
  2284. +       if (thesym->referenced)
  2285. +     /* The symbol was not defined, and we are defining it now.  */
  2286. +     undefined_global_sym_count--;
  2287. +       thesym->defined = type;
  2288. +       thesym->referenced = 1;
  2289. +       if (sym)
  2290. +     *sym = thesym;
  2291. +     }
  2292. + }
  2293. + 
  2294.   /* Create the symbol table entries for `etext', `edata' and `end'.  */
  2295.   
  2296.   void
  2297.   symtab_init ()
  2298.   {
  2299. !   symbol_define ("_edata", N_DATA | N_EXT, &edata_symbol);
  2300. !   symbol_define ("_etext", N_TEXT | N_EXT, &etext_symbol);
  2301. !   symbol_define ("_end", N_BSS | N_EXT, &end_symbol);
  2302. ! 
  2303. !   /* Either _edata or __edata (C names) is OK as far as ANSI is concerned
  2304. !      (see section 4.1.2.1).  In general, it is best to use __foo and
  2305. !      not worry about the confusing rules for the _foo namespace.
  2306. !      But HPUX 7.0 uses _edata, so we might as weel be consistent.  */
  2307. !   symbol_define ("__edata", N_DATA | N_EXT, &edata_symbol_alt);
  2308. !   symbol_define ("__etext", N_TEXT | N_EXT, &etext_symbol_alt);
  2309. !   symbol_define ("__end", N_BSS | N_EXT, &end_symbol_alt);
  2310.   
  2311.   #ifdef sun
  2312.     {
  2313. !     symbol *dynamic_symbol;
  2314. !     symbol_define ("__DYNAMIC", N_ABS | N_EXT, &dynamic_symbol);
  2315. !     if (dynamic_symbol)
  2316. !       dynamic_symbol->value = 0;
  2317. !   }
  2318. ! #endif
  2319. ! #ifdef sequent
  2320. !   {
  2321. !     symbol *i387_flt_symbol;
  2322. !     symbol_define ("_387_flt", N_ABS | N_EXT, &i387_flt_symbol);
  2323. !     if (i387_flt_symbol)
  2324. !       i387_flt_symbol->value = 0;
  2325. !   }
  2326. ! #endif
  2327. ! #ifdef NeXT
  2328. !   {
  2329. !     symbol *shlib_init_symbol;
  2330. !     symbol_define ("__shared_library_initialization", N_UNDF | N_EXT, &shlib_init_symbol);
  2331. !     if (shlib_init_symbol)
  2332. !       shlib_init_symbol->max_common_size = sizeof (long int);
  2333.     }
  2334. ! #endif
  2335.   }
  2336.   
  2337.   /* Compute the hash code for symbol name KEY.  */
  2338.